{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f543de9b-3858-45dd-bddf-cddddcc60da3",
   "metadata": {},
   "source": [
    "# Part 4: Toward Learned Receivers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c55670f1-3ee6-481d-9661-d59e61074818",
   "metadata": {},
   "source": [
    "This tutorial will guide you through Sionna, from its basic principles to the implementation of a point-to-point link with a 5G NR compliant code and a 3GPP channel model.\n",
    "You will also learn how to write custom trainable layers by implementing a state of the art neural receiver, and how to train and evaluate end-to-end communication systems.\n",
    "\n",
    "The tutorial is structured in four notebooks:\n",
    "\n",
    "- Part I: Getting started with Sionna\n",
    "\n",
    "- Part II: Differentiable Communication Systems\n",
    "\n",
    "- Part III: Advanced Link-level Simulations\n",
    "\n",
    "- **Part IV: Toward Learned Receivers**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c13c44e",
   "metadata": {},
   "source": [
    "The [official documentation](https://nvlabs.github.io/sionna/phy) provides key material on how to use Sionna and how its components are implemented."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7c4211f-beee-4142-9289-c385d0180877",
   "metadata": {},
   "source": [
    "* [Imports](#Imports)\n",
    "* [Simulation Parameters](#Simulation-Parameters)\n",
    "* [Implemention of an Advanced Neural Receiver](#Implemention-of-an-Advanced-Neural-Receiver)\n",
    "* [Training the Neural Receiver](#Training-the-Neural-Receiver)\n",
    "* [Benchmarking the Neural Receiver](#Benchmarking-the-Neural-Receiver)\n",
    "* [Conclusion](#Conclusion)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74a184ac-1f64-407f-9a24-c53d40799be2",
   "metadata": {},
   "source": [
    "## Imports<a class=\"anchor\" id=\"import\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d84bd69e-59f2-4a42-8dd3-730c8c1d821e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:49:16.913856Z",
     "iopub.status.busy": "2025-03-08T13:49:16.913310Z",
     "iopub.status.idle": "2025-03-08T13:49:19.401309Z",
     "shell.execute_reply": "2025-03-08T13:49:19.400584Z"
    }
   },
   "outputs": [],
   "source": [
    "import os # Configure which GPU \n",
    "if os.getenv(\"CUDA_VISIBLE_DEVICES\") is None:\n",
    "    gpu_num = 0 # Use \"\" to use the CPU\n",
    "    os.environ[\"CUDA_VISIBLE_DEVICES\"] = f\"{gpu_num}\"\n",
    "\n",
    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'\n",
    "\n",
    "# Import Sionna\n",
    "try:\n",
    "    import sionna as sn\n",
    "    import sionna.phy\n",
    "except ImportError as e:\n",
    "    import sys\n",
    "    if 'google.colab' in sys.modules:\n",
    "       # Install Sionna in Google Colab\n",
    "       print(\"Installing Sionna and restarting the runtime. Please run the cell again.\")\n",
    "       os.system(\"pip install sionna\")\n",
    "       os.kill(os.getpid(), 5)\n",
    "    else:\n",
    "       raise e\n",
    "\n",
    "# Configure the notebook to use only a single GPU and allocate only as much memory as needed\n",
    "# For more details, see https://www.tensorflow.org/guide/gpu\n",
    "import tensorflow as tf\n",
    "gpus = tf.config.list_physical_devices('GPU')\n",
    "if gpus:\n",
    "    try:\n",
    "        tf.config.experimental.set_memory_growth(gpus[0], True)\n",
    "    except RuntimeError as e:\n",
    "        print(e) \n",
    "\n",
    "# Avoid warnings from TensorFlow\n",
    "tf.get_logger().setLevel('ERROR')\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "# For saving complex Python data structures efficiently\n",
    "import pickle\n",
    "\n",
    "# For plotting\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# For the implementation of the neural receiver\n",
    "from tensorflow.keras import Model\n",
    "from tensorflow.keras.layers import Layer, Conv2D, LayerNormalization\n",
    "from tensorflow.nn import relu\n",
    "\n",
    "# Set seed for reproducable results\n",
    "sn.phy.config.seed = 42"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64d17183",
   "metadata": {},
   "source": [
    "## Simulation Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4dea9622",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:49:19.405762Z",
     "iopub.status.busy": "2025-03-08T13:49:19.405443Z",
     "iopub.status.idle": "2025-03-08T13:49:19.888751Z",
     "shell.execute_reply": "2025-03-08T13:49:19.887835Z"
    }
   },
   "outputs": [],
   "source": [
    "# Bit per channel use\n",
    "NUM_BITS_PER_SYMBOL = 2 # QPSK\n",
    "\n",
    "# Minimum value of Eb/N0 [dB] for simulations\n",
    "EBN0_DB_MIN = -3.0\n",
    "\n",
    "# Maximum value of Eb/N0 [dB] for simulations\n",
    "EBN0_DB_MAX = 5.0\n",
    "\n",
    "# How many examples are processed by Sionna in parallel\n",
    "BATCH_SIZE = 128\n",
    "\n",
    "# Coding rate\n",
    "CODERATE = 0.5\n",
    "\n",
    "# Define the number of UT and BS antennas\n",
    "NUM_UT = 1\n",
    "NUM_BS = 1\n",
    "NUM_UT_ANT = 1\n",
    "NUM_BS_ANT = 2\n",
    "\n",
    "# The number of transmitted streams is equal to the number of UT antennas\n",
    "# in both uplink and downlink\n",
    "NUM_STREAMS_PER_TX = NUM_UT_ANT\n",
    "\n",
    "# Create an RX-TX association matrix.\n",
    "# RX_TX_ASSOCIATION[i,j]=1 means that receiver i gets at least one stream\n",
    "# from transmitter j. Depending on the transmission direction (uplink or downlink),\n",
    "# the role of UT and BS can change.\n",
    "# For example, considering a system with 2 RX and 4 TX, the RX-TX\n",
    "# association matrix could be\n",
    "# [ [1 , 1, 0, 0],\n",
    "#   [0 , 0, 1, 1] ]\n",
    "# which indicates that the RX 0 receives from TX 0 and 1, and RX 1 receives from\n",
    "# TX 2 and 3.\n",
    "#\n",
    "# In this notebook, as we have only a single transmitter and receiver,\n",
    "# the RX-TX association matrix is simply:\n",
    "RX_TX_ASSOCIATION = np.array([[1]])\n",
    "\n",
    "# Instantiate a StreamManagement object\n",
    "# This determines which data streams are determined for which receiver.\n",
    "# In this simple setup, this is fairly easy. However, it can get more involved\n",
    "# for simulations with many transmitters and receivers.\n",
    "STREAM_MANAGEMENT = sn.phy.mimo.StreamManagement(RX_TX_ASSOCIATION, NUM_STREAMS_PER_TX)\n",
    "\n",
    "RESOURCE_GRID = sn.phy.ofdm.ResourceGrid(num_ofdm_symbols=14,\n",
    "                                         fft_size=76,\n",
    "                                         subcarrier_spacing=30e3,\n",
    "                                         num_tx=NUM_UT,\n",
    "                                         num_streams_per_tx=NUM_STREAMS_PER_TX,\n",
    "                                         cyclic_prefix_length=6,\n",
    "                                         pilot_pattern=\"kronecker\",\n",
    "                                         pilot_ofdm_symbol_indices=[2,11])\n",
    "\n",
    "# Carrier frequency in Hz.\n",
    "CARRIER_FREQUENCY = 2.6e9\n",
    "\n",
    "# Antenna setting\n",
    "UT_ARRAY = sn.phy.channel.tr38901.Antenna(polarization=\"single\",\n",
    "                                          polarization_type=\"V\",\n",
    "                                          antenna_pattern=\"38.901\",\n",
    "                                          carrier_frequency=CARRIER_FREQUENCY)\n",
    "BS_ARRAY = sn.phy.channel.tr38901.AntennaArray(num_rows=1,\n",
    "                                               num_cols=int(NUM_BS_ANT/2),\n",
    "                                               polarization=\"dual\",\n",
    "                                               polarization_type=\"cross\",\n",
    "                                               antenna_pattern=\"38.901\", # Try 'omni'\n",
    "                                               carrier_frequency=CARRIER_FREQUENCY)\n",
    "\n",
    "# Nominal delay spread in [s]. Please see the CDL documentation\n",
    "# about how to choose this value.\n",
    "DELAY_SPREAD = 100e-9\n",
    "\n",
    "# The `direction` determines if the UT or BS is transmitting.\n",
    "# In the `uplink`, the UT is transmitting.\n",
    "DIRECTION = \"uplink\"\n",
    "\n",
    "# Suitable values are [\"A\", \"B\", \"C\", \"D\", \"E\"]\n",
    "CDL_MODEL = \"C\"\n",
    "\n",
    "# UT speed [m/s]. BSs are always assumed to be fixed.\n",
    "# The direction of travel will chosen randomly within the x-y plane.\n",
    "SPEED = 10.0\n",
    "\n",
    "# Configure a channel impulse reponse (CIR) generator for the CDL model.\n",
    "CDL = sn.phy.channel.tr38901.CDL(CDL_MODEL,\n",
    "                                 DELAY_SPREAD,\n",
    "                                 CARRIER_FREQUENCY,\n",
    "                                 UT_ARRAY,\n",
    "                                 BS_ARRAY,\n",
    "                                 DIRECTION,\n",
    "                                 min_speed=SPEED)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "232db833-d1ca-41bb-a5a8-130969387682",
   "metadata": {},
   "source": [
    "## Implemention of an Advanced Neural Receiver"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52d6ad1e-0208-47de-8ede-0414b2138e1c",
   "metadata": {},
   "source": [
    "We will implement a state-of-the-art neural receiver that operates over the entire resource grid of received symbols."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd15d2f4",
   "metadata": {},
   "source": [
    "The neural receiver computes LLRs on the coded bits from the received resource grid of frequency-domain baseband symbols."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e35de8c",
   "metadata": {},
   "source": [
    "![Neural RX]()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34c86917",
   "metadata": {},
   "source": [
    "As shown in the following figure, the neural receiver substitutes to the channel estimator, equalizer, and demapper."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88b13bfe-2025-4df6-8aeb-54291a279afd",
   "metadata": {},
   "source": [
    "![LS-PSCI-Neural RX]()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc67f0ea-4d2a-43cf-bf5e-5d167b8657a8",
   "metadata": {},
   "source": [
    "As in [1] and [2], a neural receiver using residual convolutional layers is implemented.\n",
    "\n",
    "Convolutional layers are leveraged to efficienly process the 2D resource grid that is fed as an input to the neural receiver."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f407f34f",
   "metadata": {},
   "source": [
    "Residual (skip) connections are used to avoid gradient vanishing [3].\n",
    "\n",
    "For convenience, a Keras layer that implements a *residual block* is first defined. The Keras layer that implements the neural receiver is built by stacking such blocks. The following figure shows the architecture of the neural receiver."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c87da393-c820-498b-82af-f95ed7789e60",
   "metadata": {},
   "source": [
    "![Neural RX]()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "bf95e03d-882b-4af7-aafa-4b86a3ab334a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:49:19.894729Z",
     "iopub.status.busy": "2025-03-08T13:49:19.894370Z",
     "iopub.status.idle": "2025-03-08T13:49:19.904925Z",
     "shell.execute_reply": "2025-03-08T13:49:19.904152Z"
    }
   },
   "outputs": [],
   "source": [
    "class ResidualBlock(Layer):\n",
    "\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "\n",
    "        # Layer normalization is done over the last three dimensions: time, frequency, conv 'channels'\n",
    "        self._layer_norm_1 = LayerNormalization(axis=(-1, -2, -3))\n",
    "        self._conv_1 = Conv2D(filters=128,\n",
    "                              kernel_size=[3,3],\n",
    "                              padding='same',\n",
    "                              activation=None)\n",
    "        # Layer normalization is done over the last three dimensions: time, frequency, conv 'channels'\n",
    "        self._layer_norm_2 = LayerNormalization(axis=(-1, -2, -3))\n",
    "        self._conv_2 = Conv2D(filters=128,\n",
    "                              kernel_size=[3,3],\n",
    "                              padding='same',\n",
    "                              activation=None)\n",
    "\n",
    "    def call(self, inputs):\n",
    "        z = self._layer_norm_1(inputs)\n",
    "        z = relu(z)\n",
    "        z = self._conv_1(z)\n",
    "        z = self._layer_norm_2(z)\n",
    "        z = relu(z)\n",
    "        z = self._conv_2(z) # [batch size, num time samples, num subcarriers, num_channels]\n",
    "        # Skip connection\n",
    "        z = z + inputs\n",
    "\n",
    "        return z\n",
    "\n",
    "class NeuralReceiver(Layer):\n",
    "\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "\n",
    "        # Input convolution\n",
    "        self._input_conv = Conv2D(filters=128,\n",
    "                                  kernel_size=[3,3],\n",
    "                                  padding='same',\n",
    "                                  activation=None)\n",
    "        # Residual blocks\n",
    "        self._res_block_1 = ResidualBlock()\n",
    "        self._res_block_2 = ResidualBlock()\n",
    "        self._res_block_3 = ResidualBlock()\n",
    "        self._res_block_4 = ResidualBlock()\n",
    "        # Output conv\n",
    "        self._output_conv = Conv2D(filters=NUM_BITS_PER_SYMBOL,\n",
    "                                   kernel_size=[3,3],\n",
    "                                   padding='same',\n",
    "                                   activation=None)\n",
    "\n",
    "    def call(self, y, no):\n",
    "\n",
    "        # Assuming a single receiver, remove the num_rx dimension\n",
    "        y = tf.squeeze(y, axis=1)\n",
    "\n",
    "        # Feeding the noise power in log10 scale helps with the performance\n",
    "        no = sn.phy.utils.log10(no)\n",
    "\n",
    "        # Stacking the real and imaginary components of the different antennas along the 'channel' dimension\n",
    "        y = tf.transpose(y, [0, 2, 3, 1]) # Putting antenna dimension last\n",
    "        no = sn.phy.utils.insert_dims(no, 3, 1)\n",
    "        no = tf.tile(no, [1, y.shape[1], y.shape[2], 1])\n",
    "        # z : [batch size, num ofdm symbols, num subcarriers, 2*num rx antenna + 1]\n",
    "        z = tf.concat([tf.math.real(y),\n",
    "                       tf.math.imag(y),\n",
    "                       no], axis=-1)\n",
    "        # Input conv\n",
    "        z = self._input_conv(z)\n",
    "        # Residual blocks\n",
    "        z = self._res_block_1(z)\n",
    "        z = self._res_block_2(z)\n",
    "        z = self._res_block_3(z)\n",
    "        z = self._res_block_4(z)\n",
    "        # Output conv\n",
    "        z = self._output_conv(z)\n",
    "\n",
    "        # Reshape the input to fit what the resource grid demapper is expected\n",
    "        z = sn.phy.utils.insert_dims(z, 2, 1)\n",
    "\n",
    "        return z"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30d51dcd-0ccf-4401-9e1e-dac765e22973",
   "metadata": {},
   "source": [
    "The task of the receiver is to jointly solve, for each resource element, `NUM_BITS_PER_SYMBOL` binary classification problems in order to reconstruct the transmitted bits.\n",
    "Therefore, a natural choice for the loss function is the *binary cross-entropy* (BCE) applied to each bit and to each received symbol.\n",
    "\n",
    "*Remark:* The LLRs computed by the demapper are *logits* on the transmitted bits, and can therefore be used as-is to compute the BCE without any additional processing.\n",
    "*Remark 2:* The BCE is closely related to an achieveable information rate for bit-interleaved coded modulation systems [4,5]\n",
    "\n",
    "The next cell defines an end-to-end communication system using the neural receiver layer.\n",
    "\n",
    "At initialization, the paramater `training` indicates if the system is instantiated to be trained (`True`) or evaluated (`False`).\n",
    "\n",
    "If the system is instantiated to be trained, the outer encoder and decoder are not used as they are not required for training. Moreover, the estimated BCE is returned.\n",
    "This significantly reduces the computational complexity of training.\n",
    "\n",
    "If the system is instantiated to be evaluated, the outer encoder and decoder are used, and the transmited information and corresponding LLRs are returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c5d2605f-3b5f-481e-b5d1-48e638b9afd1",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:49:19.908357Z",
     "iopub.status.busy": "2025-03-08T13:49:19.908002Z",
     "iopub.status.idle": "2025-03-08T13:49:19.918634Z",
     "shell.execute_reply": "2025-03-08T13:49:19.917879Z"
    }
   },
   "outputs": [],
   "source": [
    "class OFDMSystemNeuralReceiver(Model): # Inherits from Keras Model\n",
    "\n",
    "    def __init__(self, training):\n",
    "        super().__init__() # Must call the Keras model initializer\n",
    "\n",
    "        self.training = training\n",
    "\n",
    "        n = int(RESOURCE_GRID.num_data_symbols*NUM_BITS_PER_SYMBOL) # Number of coded bits\n",
    "        k = int(n*CODERATE) # Number of information bits\n",
    "        self.k = k\n",
    "        self.n = n\n",
    "\n",
    "        # The binary source will create batches of information bits\n",
    "        self.binary_source = sn.phy.mapping.BinarySource()\n",
    "\n",
    "        # The encoder maps information bits to coded bits\n",
    "        self.encoder = sn.phy.fec.ldpc.LDPC5GEncoder(k, n)\n",
    "\n",
    "        # The mapper maps blocks of information bits to constellation symbols\n",
    "        self.mapper = sn.phy.mapping.Mapper(\"qam\", NUM_BITS_PER_SYMBOL)\n",
    "\n",
    "        # The resource grid mapper maps symbols onto an OFDM resource grid\n",
    "        self.rg_mapper = sn.phy.ofdm.ResourceGridMapper(RESOURCE_GRID)\n",
    "\n",
    "        # Frequency domain channel\n",
    "        self.channel = sn.phy.channel.OFDMChannel(CDL, RESOURCE_GRID, add_awgn=True, normalize_channel=True, return_channel=False)\n",
    "\n",
    "        # Neural receiver\n",
    "        self.neural_receiver = NeuralReceiver()\n",
    "\n",
    "        # Used to extract data-carrying resource elements\n",
    "        self.rg_demapper = sn.phy.ofdm.ResourceGridDemapper(RESOURCE_GRID, STREAM_MANAGEMENT)\n",
    "\n",
    "        # The decoder provides hard-decisions on the information bits\n",
    "        self.decoder = sn.phy.fec.ldpc.LDPC5GDecoder(self.encoder, hard_out=True)\n",
    "\n",
    "        # Loss function\n",
    "        self.bce = tf.keras.losses.BinaryCrossentropy(from_logits=True) # Loss function\n",
    "\n",
    "    @tf.function # Graph execution to speed things up\n",
    "    def __call__(self, batch_size, ebno_db):\n",
    "        no = sn.phy.utils.ebnodb2no(ebno_db, num_bits_per_symbol=NUM_BITS_PER_SYMBOL, coderate=CODERATE, resource_grid=RESOURCE_GRID)\n",
    "\n",
    "        # The neural receiver is expected no to have shape [batch_size].\n",
    "        if len(no.shape) == 0:\n",
    "            no = tf.fill([batch_size], no)\n",
    "\n",
    "        # Transmitter\n",
    "        # Outer coding is only performed if not training\n",
    "        if self.training:\n",
    "            codewords = self.binary_source([batch_size, NUM_UT, NUM_UT_ANT, self.n])\n",
    "        else:\n",
    "            bits = self.binary_source([batch_size, NUM_UT, NUM_UT_ANT, self.k])\n",
    "            codewords = self.encoder(bits)\n",
    "        x = self.mapper(codewords)\n",
    "        x_rg = self.rg_mapper(x)\n",
    "\n",
    "        # Channel\n",
    "        y = self.channel(x_rg, no)\n",
    "\n",
    "        # Receiver\n",
    "        llr = self.neural_receiver(y, no)\n",
    "        llr = self.rg_demapper(llr) # Extract data-carrying resource elements. The other LLrs are discarded\n",
    "        llr = tf.reshape(llr, [batch_size, NUM_UT, NUM_UT_ANT, self.n]) # Reshape the LLRs to fit what the outer decoder is expected\n",
    "        if self.training:\n",
    "            loss = self.bce(codewords, llr)\n",
    "            return loss\n",
    "        else:\n",
    "            bits_hat = self.decoder(llr)\n",
    "            return bits, bits_hat"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4982feda-3b93-46dc-a936-bd225d7260dd",
   "metadata": {},
   "source": [
    "## Training the Neural Receiver"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "257d7e00-7341-4542-bc75-d9a612fba091",
   "metadata": {},
   "source": [
    "The next cell implements a training loop of `NUM_TRAINING_ITERATIONS` iterations.\n",
    "\n",
    "At each iteration:\n",
    "- A batch of SNRs $E_b/N_0$ is sampled\n",
    "- A forward pass through the end-to-end system is performed within a gradient tape\n",
    "- The gradients are computed using the gradient tape, and applied using the Adam optimizer\n",
    "- A progress bar is periodically updated to follow the progress of training\n",
    "\n",
    "After training, the weights of the models are saved in a file using [pickle](https://docs.python.org/3/library/pickle.html).\n",
    "\n",
    "Executing the next cell will take quite a while. If you do not want to train your own neural receiver, you can download the weights [here](https://drive.google.com/file/d/15txi7jAgSYeg8ylx5BAygYnywcGFw9WH/view?usp=sharing) and use them later on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c53960db-28ee-4f33-8840-7b1373348162",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:49:19.922260Z",
     "iopub.status.busy": "2025-03-08T13:49:19.922014Z",
     "iopub.status.idle": "2025-03-08T13:49:19.928286Z",
     "shell.execute_reply": "2025-03-08T13:49:19.927525Z"
    }
   },
   "outputs": [],
   "source": [
    "train = False # Chane to train your own model\n",
    "if train :\n",
    "    # Number of iterations used for training\n",
    "    NUM_TRAINING_ITERATIONS = 100000\n",
    "\n",
    "    # Instantiating the end-to-end model for training\n",
    "    model = OFDMSystemNeuralReceiver(training=True)\n",
    "\n",
    "    # Adam optimizer (SGD variant)\n",
    "    optimizer = tf.keras.optimizers.Adam()\n",
    "\n",
    "    # Training loop\n",
    "    for i in range(NUM_TRAINING_ITERATIONS):\n",
    "        # Sample a batch of SNRs.\n",
    "        ebno_db = tf.random.uniform(shape=[BATCH_SIZE], minval=EBN0_DB_MIN, maxval=EBN0_DB_MAX)\n",
    "        # Forward pass\n",
    "        with tf.GradientTape() as tape:\n",
    "            loss = model(BATCH_SIZE, ebno_db)\n",
    "        # Computing and applying gradients\n",
    "        weights = model.trainable_weights\n",
    "        grads = tape.gradient(loss, weights)\n",
    "        optimizer.apply_gradients(zip(grads, weights))\n",
    "        # Print progress\n",
    "        if i % 100 == 0:\n",
    "            print(f\"{i}/{NUM_TRAINING_ITERATIONS}  Loss: {loss:.2E}\", end=\"\\r\")\n",
    "    # Save the weightsin a file\n",
    "    weights = model.get_weights()\n",
    "    with open('weights-ofdm-neuralrx', 'wb') as f:\n",
    "        pickle.dump(weights, f)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c374949",
   "metadata": {},
   "source": [
    "## Benchmarking the Neural Receiver"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bc9252a-47ee-4c2b-9224-194c90d7f4f2",
   "metadata": {},
   "source": [
    "We evaluate the trained model and benchmark it against the previously introduced baselines.\n",
    "\n",
    "We first define and evaluate the baselines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "22f04eb2",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:49:19.931404Z",
     "iopub.status.busy": "2025-03-08T13:49:19.931162Z",
     "iopub.status.idle": "2025-03-08T13:49:19.940729Z",
     "shell.execute_reply": "2025-03-08T13:49:19.939797Z"
    }
   },
   "outputs": [],
   "source": [
    "class OFDMSystem(Model): # Inherits from Keras Model\n",
    "\n",
    "    def __init__(self, perfect_csi):\n",
    "        super().__init__() # Must call the Keras model initializer\n",
    "\n",
    "        self.perfect_csi = perfect_csi\n",
    "\n",
    "        n = int(RESOURCE_GRID.num_data_symbols*NUM_BITS_PER_SYMBOL) # Number of coded bits\n",
    "        k = int(n*CODERATE) # Number of information bits\n",
    "        self.k = k\n",
    "\n",
    "        # The binary source will create batches of information bits\n",
    "        self.binary_source = sn.phy.mapping.BinarySource()\n",
    "\n",
    "        # The encoder maps information bits to coded bits\n",
    "        self.encoder = sn.phy.fec.ldpc.LDPC5GEncoder(k, n)\n",
    "\n",
    "        # The mapper maps blocks of information bits to constellation symbols\n",
    "        self.mapper = sn.phy.mapping.Mapper(\"qam\", NUM_BITS_PER_SYMBOL)\n",
    "\n",
    "        # The resource grid mapper maps symbols onto an OFDM resource grid\n",
    "        self.rg_mapper = sn.phy.ofdm.ResourceGridMapper(RESOURCE_GRID)\n",
    "\n",
    "        # Frequency domain channel\n",
    "        self.channel = sn.phy.channel.OFDMChannel(CDL, RESOURCE_GRID, add_awgn=True, normalize_channel=True, return_channel=True)\n",
    "\n",
    "        # The LS channel estimator will provide channel estimates and error variances\n",
    "        self.ls_est = sn.phy.ofdm.LSChannelEstimator(RESOURCE_GRID, interpolation_type=\"nn\")\n",
    "\n",
    "        # The LMMSE equalizer will provide soft symbols together with noise variance estimates\n",
    "        self.lmmse_equ = sn.phy.ofdm.LMMSEEqualizer(RESOURCE_GRID, STREAM_MANAGEMENT)\n",
    "\n",
    "        # The demapper produces LLR for all coded bits\n",
    "        self.demapper = sn.phy.mapping.Demapper(\"app\", \"qam\", NUM_BITS_PER_SYMBOL)\n",
    "\n",
    "        # The decoder provides hard-decisions on the information bits\n",
    "        self.decoder = sn.phy.fec.ldpc.LDPC5GDecoder(self.encoder, hard_out=True)\n",
    "\n",
    "    @tf.function # Graph execution to speed things up\n",
    "    def __call__(self, batch_size, ebno_db):\n",
    "        no = sn.phy.utils.ebnodb2no(ebno_db, num_bits_per_symbol=NUM_BITS_PER_SYMBOL, coderate=CODERATE, resource_grid=RESOURCE_GRID)\n",
    "\n",
    "        # Transmitter\n",
    "        bits = self.binary_source([batch_size, NUM_UT, RESOURCE_GRID.num_streams_per_tx, self.k])\n",
    "        codewords = self.encoder(bits)\n",
    "        x = self.mapper(codewords)\n",
    "        x_rg = self.rg_mapper(x)\n",
    "\n",
    "        # Channel\n",
    "        y, h_freq = self.channel(x_rg, no)\n",
    "\n",
    "        # Receiver\n",
    "        if self.perfect_csi:\n",
    "            h_hat, err_var = h_freq, 0.\n",
    "        else:\n",
    "            h_hat, err_var = self.ls_est (y, no)\n",
    "        x_hat, no_eff = self.lmmse_equ(y, h_hat, err_var, no)\n",
    "        llr = self.demapper(x_hat, no_eff)\n",
    "        bits_hat = self.decoder(llr)\n",
    "\n",
    "        return bits, bits_hat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2226b31a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:49:19.943966Z",
     "iopub.status.busy": "2025-03-08T13:49:19.943717Z",
     "iopub.status.idle": "2025-03-08T13:50:17.252066Z",
     "shell.execute_reply": "2025-03-08T13:50:17.251146Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EbNo [dB] |        BER |       BLER |  bit errors |    num bits | block errors |  num blocks | runtime [s] |    status\n",
      "---------------------------------------------------------------------------------------------------------------------------------------\n",
      "     -3.0 | 3.6858e-01 | 1.0000e+00 |       43026 |      116736 |          128 |         128 |        10.8 |reached target block errors\n",
      "   -2.579 | 3.5468e-01 | 1.0000e+00 |       41404 |      116736 |          128 |         128 |         0.1 |reached target block errors\n",
      "   -2.158 | 3.4774e-01 | 1.0000e+00 |       40594 |      116736 |          128 |         128 |         0.1 |reached target block errors\n",
      "   -1.737 | 3.3398e-01 | 1.0000e+00 |       38987 |      116736 |          128 |         128 |         0.1 |reached target block errors\n",
      "   -1.316 | 3.2021e-01 | 1.0000e+00 |       37380 |      116736 |          128 |         128 |         0.1 |reached target block errors\n",
      "   -0.895 | 3.0953e-01 | 1.0000e+00 |       36133 |      116736 |          128 |         128 |         0.1 |reached target block errors\n",
      "   -0.474 | 2.9626e-01 | 1.0000e+00 |       34584 |      116736 |          128 |         128 |         0.1 |reached target block errors\n",
      "   -0.053 | 2.7653e-01 | 1.0000e+00 |       32281 |      116736 |          128 |         128 |         0.1 |reached target block errors\n",
      "    0.368 | 2.5855e-01 | 1.0000e+00 |       30182 |      116736 |          128 |         128 |         0.1 |reached target block errors\n",
      "    0.789 | 2.4379e-01 | 1.0000e+00 |       28459 |      116736 |          128 |         128 |         0.1 |reached target block errors\n",
      "    1.211 | 2.2006e-01 | 1.0000e+00 |       25689 |      116736 |          128 |         128 |         0.1 |reached target block errors\n",
      "    1.632 | 1.9551e-01 | 1.0000e+00 |       22823 |      116736 |          128 |         128 |         0.1 |reached target block errors\n",
      "    2.053 | 1.6506e-01 | 1.0000e+00 |       19269 |      116736 |          128 |         128 |         0.1 |reached target block errors\n",
      "    2.474 | 9.2636e-02 | 9.0625e-01 |       10814 |      116736 |          116 |         128 |         0.1 |reached target block errors\n",
      "    2.895 | 2.3466e-02 | 3.5677e-01 |        8218 |      350208 |          137 |         384 |         0.2 |reached target block errors\n",
      "    3.316 | 1.3559e-03 | 3.7202e-02 |        3324 |     2451456 |          100 |        2688 |         1.5 |reached target block errors\n",
      "    3.737 | 1.4032e-04 | 1.8750e-03 |        1638 |    11673600 |           24 |       12800 |         7.2 |reached max iterations\n",
      "    4.158 | 0.0000e+00 | 0.0000e+00 |           0 |    11673600 |            0 |       12800 |         7.3 |reached max iterations\n",
      "\n",
      "Simulation stopped as no error occurred @ EbNo = 4.2 dB.\n",
      "\n",
      "EbNo [dB] |        BER |       BLER |  bit errors |    num bits | block errors |  num blocks | runtime [s] |    status\n",
      "---------------------------------------------------------------------------------------------------------------------------------------\n",
      "     -3.0 | 2.1829e-01 | 1.0000e+00 |       25482 |      116736 |          128 |         128 |         2.7 |reached target block errors\n",
      "   -2.579 | 1.9817e-01 | 1.0000e+00 |       23134 |      116736 |          128 |         128 |         0.1 |reached target block errors\n",
      "   -2.158 | 1.7092e-01 | 1.0000e+00 |       19952 |      116736 |          128 |         128 |         0.1 |reached target block errors\n",
      "   -1.737 | 1.3443e-01 | 9.9219e-01 |       15693 |      116736 |          127 |         128 |         0.1 |reached target block errors\n",
      "   -1.316 | 7.5178e-02 | 8.8281e-01 |        8776 |      116736 |          113 |         128 |         0.1 |reached target block errors\n",
      "   -0.895 | 1.4149e-02 | 3.6198e-01 |        4955 |      350208 |          139 |         384 |         0.2 |reached target block errors\n",
      "   -0.474 | 8.1262e-04 | 2.7209e-02 |        2751 |     3385344 |          101 |        3712 |         2.1 |reached target block errors\n",
      "   -0.053 | 4.4631e-05 | 9.3750e-04 |         521 |    11673600 |           12 |       12800 |         7.4 |reached max iterations\n",
      "    0.368 | 2.0559e-06 | 7.8125e-05 |          24 |    11673600 |            1 |       12800 |         7.4 |reached max iterations\n",
      "    0.789 | 0.0000e+00 | 0.0000e+00 |           0 |    11673600 |            0 |       12800 |         7.4 |reached max iterations\n",
      "\n",
      "Simulation stopped as no error occurred @ EbNo = 0.8 dB.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "ber_plots = sn.phy.utils.PlotBER(\"Advanced neural receiver\")\n",
    "\n",
    "baseline_ls = OFDMSystem(False)\n",
    "ber_plots.simulate(baseline_ls,\n",
    "                  ebno_dbs=np.linspace(EBN0_DB_MIN, EBN0_DB_MAX, 20),\n",
    "                  batch_size=BATCH_SIZE,\n",
    "                  num_target_block_errors=100, # simulate until 100 block errors occured\n",
    "                  legend=\"Baseline: LS Estimation\",\n",
    "                  soft_estimates=True,\n",
    "                  max_mc_iter=100, # run 100 Monte-Carlo simulations (each with batch_size samples)\n",
    "                  show_fig=False);\n",
    "\n",
    "baseline_pcsi = OFDMSystem(True)\n",
    "ber_plots.simulate(baseline_pcsi,\n",
    "                  ebno_dbs=np.linspace(EBN0_DB_MIN, EBN0_DB_MAX, 20),\n",
    "                  batch_size=BATCH_SIZE,\n",
    "                  num_target_block_errors=100, # simulate until 100 block errors occured\n",
    "                  legend=\"Baseline: Perfect CSI\",\n",
    "                  soft_estimates=True,\n",
    "                  max_mc_iter=100, # run 100 Monte-Carlo simulations (each with batch_size samples)\n",
    "                  show_fig=False);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3de79d49",
   "metadata": {},
   "source": [
    "We then instantiate and evaluate the end-to-end system equipped with the neural receiver."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6a0e6e6b-3650-4524-9c83-46c715493e3f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:50:17.255839Z",
     "iopub.status.busy": "2025-03-08T13:50:17.255573Z",
     "iopub.status.idle": "2025-03-08T13:50:23.727054Z",
     "shell.execute_reply": "2025-03-08T13:50:23.726329Z"
    }
   },
   "outputs": [],
   "source": [
    "# Instantiating the end-to-end model for evaluation\n",
    "model_neuralrx = OFDMSystemNeuralReceiver(training=False)\n",
    "\n",
    "# Run one inference to build the layers and loading the weights\n",
    "model_neuralrx(tf.constant(1, tf.int32), tf.constant(10.0, tf.float32))\n",
    "with open('weights-ofdm-neuralrx', 'rb') as f:\n",
    "    weights = pickle.load(f)\n",
    "    model_neuralrx.set_weights(weights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "fc0e47a5-7d61-4e8b-b077-8fc63a33057f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-08T13:50:23.729860Z",
     "iopub.status.busy": "2025-03-08T13:50:23.729549Z",
     "iopub.status.idle": "2025-03-08T13:51:19.327468Z",
     "shell.execute_reply": "2025-03-08T13:51:19.326793Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EbNo [dB] |        BER |       BLER |  bit errors |    num bits | block errors |  num blocks | runtime [s] |    status\n",
      "---------------------------------------------------------------------------------------------------------------------------------------\n",
      "     -3.0 | 2.2353e-01 | 1.0000e+00 |       26094 |      116736 |          128 |         128 |         0.3 |reached target block errors\n",
      "   -2.579 | 2.0426e-01 | 1.0000e+00 |       23845 |      116736 |          128 |         128 |         0.1 |reached target block errors\n",
      "   -2.158 | 1.8083e-01 | 1.0000e+00 |       21109 |      116736 |          128 |         128 |         0.1 |reached target block errors\n",
      "   -1.737 | 1.5117e-01 | 1.0000e+00 |       17647 |      116736 |          128 |         128 |         0.1 |reached target block errors\n",
      "   -1.316 | 7.8176e-02 | 9.2188e-01 |        9126 |      116736 |          118 |         128 |         0.1 |reached target block errors\n",
      "   -0.895 | 2.7661e-02 | 5.3125e-01 |        6458 |      233472 |          136 |         256 |         0.2 |reached target block errors\n",
      "   -0.474 | 2.0445e-03 | 6.5104e-02 |        2864 |     1400832 |          100 |        1536 |         1.1 |reached target block errors\n",
      "   -0.053 | 1.1290e-04 | 2.5781e-03 |        1318 |    11673600 |           33 |       12800 |         8.8 |reached max iterations\n",
      "    0.368 | 8.5749e-05 | 7.8125e-04 |        1001 |    11673600 |           10 |       12800 |         8.8 |reached max iterations\n",
      "    0.789 | 1.6276e-05 | 2.3437e-04 |         190 |    11673600 |            3 |       12800 |         8.8 |reached max iterations\n",
      "    1.211 | 2.3729e-05 | 1.5625e-04 |         277 |    11673600 |            2 |       12800 |         8.8 |reached max iterations\n",
      "    1.632 | 1.1136e-05 | 7.8125e-05 |         130 |    11673600 |            1 |       12800 |         8.9 |reached max iterations\n",
      "    2.053 | 0.0000e+00 | 0.0000e+00 |           0 |    11673600 |            0 |       12800 |         8.8 |reached max iterations\n",
      "\n",
      "Simulation stopped as no error occurred @ EbNo = 2.1 dB.\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Computing and plotting BER\n",
    "ber_plots.simulate(model_neuralrx,\n",
    "                  ebno_dbs=np.linspace(EBN0_DB_MIN, EBN0_DB_MAX, 20),\n",
    "                  batch_size=BATCH_SIZE,\n",
    "                  num_target_block_errors=100,\n",
    "                  legend=\"Neural Receiver\",\n",
    "                  soft_estimates=True,\n",
    "                  max_mc_iter=100,\n",
    "                  show_fig=True);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc0e6bc1-cd3f-4ecb-86b3-d30c4499c1f5",
   "metadata": {},
   "source": [
    "## Conclusion <a class=\"anchor\" id=\"Conclusion\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2cceaaa-35bc-479e-8006-773c1172e117",
   "metadata": {},
   "source": [
    "We hope you are excited about Sionna - there is much more to be discovered:\n",
    "\n",
    "- TensorBoard debugging available\n",
    "- Scaling to multi-GPU simulation is simple\n",
    "- See the [available tutorials](https://nvlabs.github.io/sionna/phy/tutorials.html) for more examples\n",
    "\n",
    "And if something is still missing - the project is open-source: you can modify, add, and extend any component at any time."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1712c31-04f3-4c71-b7ba-b8e63c4ac126",
   "metadata": {},
   "source": [
    "## References"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3887c8aa-23ed-4a27-ad9d-0a1e3174c2c2",
   "metadata": {},
   "source": [
    "[1] [M. Honkala, D. Korpi and J. M. J. Huttunen, \"DeepRx: Fully Convolutional Deep Learning Receiver,\" in IEEE Transactions on Wireless Communications, vol. 20, no. 6, pp. 3925-3940, June 2021, doi: 10.1109/TWC.2021.3054520](https://ieeexplore.ieee.org/abstract/document/9345504).\n",
    "\n",
    "[2] [F. Ait Aoudia and J. Hoydis, \"End-to-end Learning for OFDM: From Neural Receivers to Pilotless Communication,\" in IEEE Transactions on Wireless Communications, doi: 10.1109/TWC.2021.3101364](https://ieeexplore.ieee.org/abstract/document/9508784).\n",
    "\n",
    "[3] [Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun, \"Deep Residual Learning for Image Recognition\", Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2016, pp. 770-778](https://openaccess.thecvf.com/content_cvpr_2016/html/He_Deep_Residual_Learning_CVPR_2016_paper.html)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.16"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
